home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / alsa / control.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-01-09  |  24.2 KB  |  526 lines
  1. /**
  2.  * \file include/control.h
  3.  * \brief Application interface library for the ALSA driver
  4.  * \author Jaroslav Kysela <perex@suse.cz>
  5.  * \author Abramo Bagnara <abramo@alsa-project.org>
  6.  * \author Takashi Iwai <tiwai@suse.de>
  7.  * \date 1998-2001
  8.  *
  9.  * Application interface library for the ALSA driver
  10.  */
  11. /*
  12.  *   This library is free software; you can redistribute it and/or modify
  13.  *   it under the terms of the GNU Lesser General Public License as
  14.  *   published by the Free Software Foundation; either version 2.1 of
  15.  *   the License, or (at your option) any later version.
  16.  *
  17.  *   This program is distributed in the hope that it will be useful,
  18.  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  19.  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20.  *   GNU Lesser General Public License for more details.
  21.  *
  22.  *   You should have received a copy of the GNU Lesser General Public
  23.  *   License along with this library; if not, write to the Free Software
  24.  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  25.  *
  26.  */
  27.  
  28. #ifndef __ALSA_CONTROL_H
  29. #define __ALSA_CONTROL_H
  30.  
  31. #ifdef __cplusplus
  32. extern "C" {
  33. #endif
  34.  
  35. /**
  36.  *  \defgroup Control Control Interface
  37.  *  The control interface.
  38.  *  See \ref control page for more details.
  39.  *  \{
  40.  */
  41.  
  42. /** dlsym version for interface entry callback */
  43. #define SND_CONTROL_DLSYM_VERSION    _dlsym_control_001
  44.  
  45. /** IEC958 structure */
  46. typedef struct snd_aes_iec958 {
  47.     unsigned char status[24];    /**< AES/IEC958 channel status bits */
  48.     unsigned char subcode[147];    /**< AES/IEC958 subcode bits */
  49.     unsigned char pad;        /**< nothing */
  50.     unsigned char dig_subframe[4];    /**< AES/IEC958 subframe bits */
  51. } snd_aes_iec958_t;
  52.  
  53. /** CTL card info container */
  54. typedef struct _snd_ctl_card_info snd_ctl_card_info_t;
  55.  
  56. /** CTL element identifier container */
  57. typedef struct _snd_ctl_elem_id snd_ctl_elem_id_t;
  58.  
  59. /** CTL element identifier list container */
  60. typedef struct _snd_ctl_elem_list snd_ctl_elem_list_t;
  61.  
  62. /** CTL element info container */
  63. typedef struct _snd_ctl_elem_info snd_ctl_elem_info_t;
  64.  
  65. /** CTL element value container */
  66. typedef struct _snd_ctl_elem_value snd_ctl_elem_value_t;
  67.  
  68. /** CTL event container */
  69. typedef struct _snd_ctl_event snd_ctl_event_t;
  70.  
  71. /** CTL element type */
  72. typedef enum _snd_ctl_elem_type {
  73.     /** Invalid type */
  74.     SND_CTL_ELEM_TYPE_NONE = 0,
  75.     /** Boolean contents */
  76.     SND_CTL_ELEM_TYPE_BOOLEAN,
  77.     /** Integer contents */
  78.     SND_CTL_ELEM_TYPE_INTEGER,
  79.     /** Enumerated contents */
  80.     SND_CTL_ELEM_TYPE_ENUMERATED,
  81.     /** Bytes contents */
  82.     SND_CTL_ELEM_TYPE_BYTES,
  83.     /** IEC958 (S/PDIF) setting content */
  84.     SND_CTL_ELEM_TYPE_IEC958,
  85.     /** 64-bit integer contents */
  86.     SND_CTL_ELEM_TYPE_INTEGER64,
  87.     SND_CTL_ELEM_TYPE_LAST = SND_CTL_ELEM_TYPE_INTEGER64
  88. } snd_ctl_elem_type_t;
  89.  
  90. /** CTL related interface */
  91. typedef enum _snd_ctl_elem_iface {
  92.     /** Card level */
  93.     SND_CTL_ELEM_IFACE_CARD = 0,
  94.     /** Hardware dependent device */
  95.     SND_CTL_ELEM_IFACE_HWDEP,
  96.     /** Mixer */
  97.     SND_CTL_ELEM_IFACE_MIXER,
  98.     /** PCM */
  99.     SND_CTL_ELEM_IFACE_PCM,
  100.     /** RawMidi */
  101.     SND_CTL_ELEM_IFACE_RAWMIDI,
  102.     /** Timer */
  103.     SND_CTL_ELEM_IFACE_TIMER,
  104.     /** Sequencer */
  105.     SND_CTL_ELEM_IFACE_SEQUENCER,
  106.     SND_CTL_ELEM_IFACE_LAST = SND_CTL_ELEM_IFACE_SEQUENCER
  107. } snd_ctl_elem_iface_t;
  108.  
  109. /** Event class */
  110. typedef enum _snd_ctl_event_type {
  111.     /** Elements related event */
  112.     SND_CTL_EVENT_ELEM = 0,
  113.     SND_CTL_EVENT_LAST = SND_CTL_EVENT_ELEM
  114. }snd_ctl_event_type_t;
  115.  
  116. /** Element has been removed (Warning: test this first and if set don't
  117.   * test the other masks) \hideinitializer */
  118. #define SND_CTL_EVENT_MASK_REMOVE     (~0U)
  119. /** Element value has been changed \hideinitializer */
  120. #define SND_CTL_EVENT_MASK_VALUE    (1<<0)
  121. /** Element info has been changed \hideinitializer */
  122. #define SND_CTL_EVENT_MASK_INFO        (1<<1)
  123. /** Element has been added \hideinitializer */
  124. #define SND_CTL_EVENT_MASK_ADD        (1<<2)
  125.  
  126. /** CTL name helper */
  127. #define SND_CTL_NAME_NONE                ""
  128. /** CTL name helper */
  129. #define SND_CTL_NAME_PLAYBACK                "Playback "
  130. /** CTL name helper */
  131. #define SND_CTL_NAME_CAPTURE                "Capture "
  132.  
  133. /** CTL name helper */
  134. #define SND_CTL_NAME_IEC958_NONE            ""
  135. /** CTL name helper */
  136. #define SND_CTL_NAME_IEC958_SWITCH            "Switch"
  137. /** CTL name helper */
  138. #define SND_CTL_NAME_IEC958_VOLUME            "Volume"
  139. /** CTL name helper */
  140. #define SND_CTL_NAME_IEC958_DEFAULT            "Default"
  141. /** CTL name helper */
  142. #define SND_CTL_NAME_IEC958_MASK            "Mask"
  143. /** CTL name helper */
  144. #define SND_CTL_NAME_IEC958_CON_MASK            "Con Mask"
  145. /** CTL name helper */
  146. #define SND_CTL_NAME_IEC958_PRO_MASK            "Pro Mask"
  147. /** CTL name helper */
  148. #define SND_CTL_NAME_IEC958_PCM_STREAM            "PCM Stream"
  149. /** Element name for IEC958 (S/PDIF) */
  150. #define SND_CTL_NAME_IEC958(expl,direction,what)    "IEC958 " expl SND_CTL_NAME_##direction SND_CTL_NAME_IEC958_##what
  151.  
  152. /** Mask for the major Power State identifier */
  153. #define SND_CTL_POWER_MASK        0xff00
  154. /** ACPI/PCI Power State D0 */
  155. #define SND_CTL_POWER_D0              0x0000
  156. /** ACPI/PCI Power State D1 */
  157. #define SND_CTL_POWER_D1                  0x0100
  158. /** ACPI/PCI Power State D2 */
  159. #define SND_CTL_POWER_D2             0x0200
  160. /** ACPI/PCI Power State D3 */
  161. #define SND_CTL_POWER_D3             0x0300
  162. /** ACPI/PCI Power State D3hot */
  163. #define SND_CTL_POWER_D3hot        (SND_CTL_POWER_D3|0x0000)
  164. /** ACPI/PCI Power State D3cold */
  165. #define SND_CTL_POWER_D3cold              (SND_CTL_POWER_D3|0x0001)
  166.  
  167. /** CTL type */
  168. typedef enum _snd_ctl_type {
  169.     /** Kernel level CTL */
  170.     SND_CTL_TYPE_HW,
  171.     /** Shared memory client CTL */
  172.     SND_CTL_TYPE_SHM,
  173.     /** INET client CTL (not yet implemented) */
  174.     SND_CTL_TYPE_INET,
  175.     /** External control plugin */
  176.     SND_CTL_TYPE_EXT
  177. } snd_ctl_type_t;
  178.  
  179. /** Non blocking mode (flag for open mode) \hideinitializer */
  180. #define SND_CTL_NONBLOCK        0x0001
  181.  
  182. /** Async notification (flag for open mode) \hideinitializer */
  183. #define SND_CTL_ASYNC            0x0002
  184.  
  185. /** Read only (flag for open mode) \hideinitializer */
  186. #define SND_CTL_READONLY        0x0004
  187.  
  188. /** CTL handle */
  189. typedef struct _snd_ctl snd_ctl_t;
  190.  
  191. /** Don't destroy the ctl handle when close */
  192. #define SND_SCTL_NOFREE            0x0001
  193.  
  194. /** SCTL type */
  195. typedef struct _snd_sctl snd_sctl_t;
  196.  
  197. int snd_card_load(int card);
  198. int snd_card_next(int *card);
  199. int snd_card_get_index(const char *name);
  200. int snd_card_get_name(int card, char **name);
  201. int snd_card_get_longname(int card, char **name);
  202.  
  203. int snd_ctl_open(snd_ctl_t **ctl, const char *name, int mode);
  204. int snd_ctl_open_lconf(snd_ctl_t **ctl, const char *name, int mode, snd_config_t *lconf);
  205. int snd_ctl_close(snd_ctl_t *ctl);
  206. int snd_ctl_nonblock(snd_ctl_t *ctl, int nonblock);
  207. int snd_async_add_ctl_handler(snd_async_handler_t **handler, snd_ctl_t *ctl, 
  208.                   snd_async_callback_t callback, void *private_data);
  209. snd_ctl_t *snd_async_handler_get_ctl(snd_async_handler_t *handler);
  210. int snd_ctl_poll_descriptors_count(snd_ctl_t *ctl);
  211. int snd_ctl_poll_descriptors(snd_ctl_t *ctl, struct pollfd *pfds, unsigned int space);
  212. int snd_ctl_poll_descriptors_revents(snd_ctl_t *ctl, struct pollfd *pfds, unsigned int nfds, unsigned short *revents);
  213. int snd_ctl_subscribe_events(snd_ctl_t *ctl, int subscribe);
  214. int snd_ctl_card_info(snd_ctl_t *ctl, snd_ctl_card_info_t *info);
  215. int snd_ctl_elem_list(snd_ctl_t *ctl, snd_ctl_elem_list_t * list);
  216. int snd_ctl_elem_info(snd_ctl_t *ctl, snd_ctl_elem_info_t *info);
  217. int snd_ctl_elem_read(snd_ctl_t *ctl, snd_ctl_elem_value_t *value);
  218. int snd_ctl_elem_write(snd_ctl_t *ctl, snd_ctl_elem_value_t *value);
  219. int snd_ctl_elem_lock(snd_ctl_t *ctl, snd_ctl_elem_id_t *id);
  220. int snd_ctl_elem_unlock(snd_ctl_t *ctl, snd_ctl_elem_id_t *id);
  221. int snd_ctl_hwdep_next_device(snd_ctl_t *ctl, int * device);
  222. int snd_ctl_hwdep_info(snd_ctl_t *ctl, snd_hwdep_info_t * info);
  223. int snd_ctl_pcm_next_device(snd_ctl_t *ctl, int *device);
  224. int snd_ctl_pcm_info(snd_ctl_t *ctl, snd_pcm_info_t * info);
  225. int snd_ctl_pcm_prefer_subdevice(snd_ctl_t *ctl, int subdev);
  226. int snd_ctl_rawmidi_next_device(snd_ctl_t *ctl, int * device);
  227. int snd_ctl_rawmidi_info(snd_ctl_t *ctl, snd_rawmidi_info_t * info);
  228. int snd_ctl_rawmidi_prefer_subdevice(snd_ctl_t *ctl, int subdev);
  229. int snd_ctl_set_power_state(snd_ctl_t *ctl, unsigned int state);
  230. int snd_ctl_get_power_state(snd_ctl_t *ctl, unsigned int *state);
  231.  
  232. int snd_ctl_read(snd_ctl_t *ctl, snd_ctl_event_t *event);
  233. int snd_ctl_wait(snd_ctl_t *ctl, int timeout);
  234. const char *snd_ctl_name(snd_ctl_t *ctl);
  235. snd_ctl_type_t snd_ctl_type(snd_ctl_t *ctl);
  236.  
  237. const char *snd_ctl_elem_type_name(snd_ctl_elem_type_t type);
  238. const char *snd_ctl_elem_iface_name(snd_ctl_elem_iface_t iface);
  239. const char *snd_ctl_event_type_name(snd_ctl_event_type_t type);
  240.  
  241. unsigned int snd_ctl_event_elem_get_mask(const snd_ctl_event_t *obj);
  242. unsigned int snd_ctl_event_elem_get_numid(const snd_ctl_event_t *obj);
  243. void snd_ctl_event_elem_get_id(const snd_ctl_event_t *obj, snd_ctl_elem_id_t *ptr);
  244. snd_ctl_elem_iface_t snd_ctl_event_elem_get_interface(const snd_ctl_event_t *obj);
  245. unsigned int snd_ctl_event_elem_get_device(const snd_ctl_event_t *obj);
  246. unsigned int snd_ctl_event_elem_get_subdevice(const snd_ctl_event_t *obj);
  247. const char *snd_ctl_event_elem_get_name(const snd_ctl_event_t *obj);
  248. unsigned int snd_ctl_event_elem_get_index(const snd_ctl_event_t *obj);
  249.  
  250. int snd_ctl_elem_list_alloc_space(snd_ctl_elem_list_t *obj, unsigned int entries);
  251. void snd_ctl_elem_list_free_space(snd_ctl_elem_list_t *obj);
  252.  
  253. size_t snd_ctl_elem_id_sizeof(void);
  254. /** \hideinitializer
  255.  * \brief allocate an invalid #snd_ctl_elem_id_t using standard alloca
  256.  * \param ptr returned pointer
  257.  */
  258. #define snd_ctl_elem_id_alloca(ptr) do { assert(ptr); *ptr = (snd_ctl_elem_id_t *) alloca(snd_ctl_elem_id_sizeof()); memset(*ptr, 0, snd_ctl_elem_id_sizeof()); } while (0)
  259. int snd_ctl_elem_id_malloc(snd_ctl_elem_id_t **ptr);
  260. void snd_ctl_elem_id_free(snd_ctl_elem_id_t *obj);
  261. void snd_ctl_elem_id_clear(snd_ctl_elem_id_t *obj);
  262. void snd_ctl_elem_id_copy(snd_ctl_elem_id_t *dst, const snd_ctl_elem_id_t *src);
  263. unsigned int snd_ctl_elem_id_get_numid(const snd_ctl_elem_id_t *obj);
  264. snd_ctl_elem_iface_t snd_ctl_elem_id_get_interface(const snd_ctl_elem_id_t *obj);
  265. unsigned int snd_ctl_elem_id_get_device(const snd_ctl_elem_id_t *obj);
  266. unsigned int snd_ctl_elem_id_get_subdevice(const snd_ctl_elem_id_t *obj);
  267. const char *snd_ctl_elem_id_get_name(const snd_ctl_elem_id_t *obj);
  268. unsigned int snd_ctl_elem_id_get_index(const snd_ctl_elem_id_t *obj);
  269. void snd_ctl_elem_id_set_numid(snd_ctl_elem_id_t *obj, unsigned int val);
  270. void snd_ctl_elem_id_set_interface(snd_ctl_elem_id_t *obj, snd_ctl_elem_iface_t val);
  271. void snd_ctl_elem_id_set_device(snd_ctl_elem_id_t *obj, unsigned int val);
  272. void snd_ctl_elem_id_set_subdevice(snd_ctl_elem_id_t *obj, unsigned int val);
  273. void snd_ctl_elem_id_set_name(snd_ctl_elem_id_t *obj, const char *val);
  274. void snd_ctl_elem_id_set_index(snd_ctl_elem_id_t *obj, unsigned int val);
  275.  
  276. size_t snd_ctl_card_info_sizeof(void);
  277. /** \hideinitializer
  278.  * \brief allocate an invalid #snd_ctl_card_info_t using standard alloca
  279.  * \param ptr returned pointer
  280.  */
  281. #define snd_ctl_card_info_alloca(ptr) do { assert(ptr); *ptr = (snd_ctl_card_info_t *) alloca(snd_ctl_card_info_sizeof()); memset(*ptr, 0, snd_ctl_card_info_sizeof()); } while (0)
  282. int snd_ctl_card_info_malloc(snd_ctl_card_info_t **ptr);
  283. void snd_ctl_card_info_free(snd_ctl_card_info_t *obj);
  284. void snd_ctl_card_info_clear(snd_ctl_card_info_t *obj);
  285. void snd_ctl_card_info_copy(snd_ctl_card_info_t *dst, const snd_ctl_card_info_t *src);
  286. int snd_ctl_card_info_get_card(const snd_ctl_card_info_t *obj);
  287. const char *snd_ctl_card_info_get_id(const snd_ctl_card_info_t *obj);
  288. const char *snd_ctl_card_info_get_driver(const snd_ctl_card_info_t *obj);
  289. const char *snd_ctl_card_info_get_name(const snd_ctl_card_info_t *obj);
  290. const char *snd_ctl_card_info_get_longname(const snd_ctl_card_info_t *obj);
  291. const char *snd_ctl_card_info_get_mixername(const snd_ctl_card_info_t *obj);
  292. const char *snd_ctl_card_info_get_components(const snd_ctl_card_info_t *obj);
  293.  
  294. size_t snd_ctl_event_sizeof(void);
  295. /** \hideinitializer
  296.  * \brief allocate an invalid #snd_ctl_event_t using standard alloca
  297.  * \param ptr returned pointer
  298.  */
  299. #define snd_ctl_event_alloca(ptr) do { assert(ptr); *ptr = (snd_ctl_event_t *) alloca(snd_ctl_event_sizeof()); memset(*ptr, 0, snd_ctl_event_sizeof()); } while (0)
  300. int snd_ctl_event_malloc(snd_ctl_event_t **ptr);
  301. void snd_ctl_event_free(snd_ctl_event_t *obj);
  302. void snd_ctl_event_clear(snd_ctl_event_t *obj);
  303. void snd_ctl_event_copy(snd_ctl_event_t *dst, const snd_ctl_event_t *src);
  304. snd_ctl_event_type_t snd_ctl_event_get_type(const snd_ctl_event_t *obj);
  305.  
  306. size_t snd_ctl_elem_list_sizeof(void);
  307. /** \hideinitializer
  308.  * \brief allocate an invalid #snd_ctl_elem_list_t using standard alloca
  309.  * \param ptr returned pointer
  310.  */
  311. #define snd_ctl_elem_list_alloca(ptr) do { assert(ptr); *ptr = (snd_ctl_elem_list_t *) alloca(snd_ctl_elem_list_sizeof()); memset(*ptr, 0, snd_ctl_elem_list_sizeof()); } while (0)
  312. int snd_ctl_elem_list_malloc(snd_ctl_elem_list_t **ptr);
  313. void snd_ctl_elem_list_free(snd_ctl_elem_list_t *obj);
  314. void snd_ctl_elem_list_clear(snd_ctl_elem_list_t *obj);
  315. void snd_ctl_elem_list_copy(snd_ctl_elem_list_t *dst, const snd_ctl_elem_list_t *src);
  316. void snd_ctl_elem_list_set_offset(snd_ctl_elem_list_t *obj, unsigned int val);
  317. unsigned int snd_ctl_elem_list_get_used(const snd_ctl_elem_list_t *obj);
  318. unsigned int snd_ctl_elem_list_get_count(const snd_ctl_elem_list_t *obj);
  319. void snd_ctl_elem_list_get_id(const snd_ctl_elem_list_t *obj, unsigned int idx, snd_ctl_elem_id_t *ptr);
  320. unsigned int snd_ctl_elem_list_get_numid(const snd_ctl_elem_list_t *obj, unsigned int idx);
  321. snd_ctl_elem_iface_t snd_ctl_elem_list_get_interface(const snd_ctl_elem_list_t *obj, unsigned int idx);
  322. unsigned int snd_ctl_elem_list_get_device(const snd_ctl_elem_list_t *obj, unsigned int idx);
  323. unsigned int snd_ctl_elem_list_get_subdevice(const snd_ctl_elem_list_t *obj, unsigned int idx);
  324. const char *snd_ctl_elem_list_get_name(const snd_ctl_elem_list_t *obj, unsigned int idx);
  325. unsigned int snd_ctl_elem_list_get_index(const snd_ctl_elem_list_t *obj, unsigned int idx);
  326.  
  327. size_t snd_ctl_elem_info_sizeof(void);
  328. /** \hideinitializer
  329.  * \brief allocate an invalid #snd_ctl_elem_info_t using standard alloca
  330.  * \param ptr returned pointer
  331.  */
  332. #define snd_ctl_elem_info_alloca(ptr) do { assert(ptr); *ptr = (snd_ctl_elem_info_t *) alloca(snd_ctl_elem_info_sizeof()); memset(*ptr, 0, snd_ctl_elem_info_sizeof()); } while (0)
  333. int snd_ctl_elem_info_malloc(snd_ctl_elem_info_t **ptr);
  334. void snd_ctl_elem_info_free(snd_ctl_elem_info_t *obj);
  335. void snd_ctl_elem_info_clear(snd_ctl_elem_info_t *obj);
  336. void snd_ctl_elem_info_copy(snd_ctl_elem_info_t *dst, const snd_ctl_elem_info_t *src);
  337. snd_ctl_elem_type_t snd_ctl_elem_info_get_type(const snd_ctl_elem_info_t *obj);
  338. int snd_ctl_elem_info_is_readable(const snd_ctl_elem_info_t *obj);
  339. int snd_ctl_elem_info_is_writable(const snd_ctl_elem_info_t *obj);
  340. int snd_ctl_elem_info_is_volatile(const snd_ctl_elem_info_t *obj);
  341. int snd_ctl_elem_info_is_inactive(const snd_ctl_elem_info_t *obj);
  342. int snd_ctl_elem_info_is_locked(const snd_ctl_elem_info_t *obj);
  343. int snd_ctl_elem_info_is_owner(const snd_ctl_elem_info_t *obj);
  344. int snd_ctl_elem_info_is_user(const snd_ctl_elem_info_t *obj);
  345. pid_t snd_ctl_elem_info_get_owner(const snd_ctl_elem_info_t *obj);
  346. unsigned int snd_ctl_elem_info_get_count(const snd_ctl_elem_info_t *obj);
  347. long snd_ctl_elem_info_get_min(const snd_ctl_elem_info_t *obj);
  348. long snd_ctl_elem_info_get_max(const snd_ctl_elem_info_t *obj);
  349. long snd_ctl_elem_info_get_step(const snd_ctl_elem_info_t *obj);
  350. long long snd_ctl_elem_info_get_min64(const snd_ctl_elem_info_t *obj);
  351. long long snd_ctl_elem_info_get_max64(const snd_ctl_elem_info_t *obj);
  352. long long snd_ctl_elem_info_get_step64(const snd_ctl_elem_info_t *obj);
  353. unsigned int snd_ctl_elem_info_get_items(const snd_ctl_elem_info_t *obj);
  354. void snd_ctl_elem_info_set_item(snd_ctl_elem_info_t *obj, unsigned int val);
  355. const char *snd_ctl_elem_info_get_item_name(const snd_ctl_elem_info_t *obj);
  356. int snd_ctl_elem_info_get_dimensions(const snd_ctl_elem_info_t *obj);
  357. int snd_ctl_elem_info_get_dimension(const snd_ctl_elem_info_t *obj, unsigned int idx);
  358. void snd_ctl_elem_info_get_id(const snd_ctl_elem_info_t *obj, snd_ctl_elem_id_t *ptr);
  359. unsigned int snd_ctl_elem_info_get_numid(const snd_ctl_elem_info_t *obj);
  360. snd_ctl_elem_iface_t snd_ctl_elem_info_get_interface(const snd_ctl_elem_info_t *obj);
  361. unsigned int snd_ctl_elem_info_get_device(const snd_ctl_elem_info_t *obj);
  362. unsigned int snd_ctl_elem_info_get_subdevice(const snd_ctl_elem_info_t *obj);
  363. const char *snd_ctl_elem_info_get_name(const snd_ctl_elem_info_t *obj);
  364. unsigned int snd_ctl_elem_info_get_index(const snd_ctl_elem_info_t *obj);
  365. void snd_ctl_elem_info_set_id(snd_ctl_elem_info_t *obj, const snd_ctl_elem_id_t *ptr);
  366. void snd_ctl_elem_info_set_numid(snd_ctl_elem_info_t *obj, unsigned int val);
  367. void snd_ctl_elem_info_set_interface(snd_ctl_elem_info_t *obj, snd_ctl_elem_iface_t val);
  368. void snd_ctl_elem_info_set_device(snd_ctl_elem_info_t *obj, unsigned int val);
  369. void snd_ctl_elem_info_set_subdevice(snd_ctl_elem_info_t *obj, unsigned int val);
  370. void snd_ctl_elem_info_set_name(snd_ctl_elem_info_t *obj, const char *val);
  371. void snd_ctl_elem_info_set_index(snd_ctl_elem_info_t *obj, unsigned int val);
  372.  
  373. int snd_ctl_elem_add_integer(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id, unsigned int count, long imin, long imax, long istep);
  374. int snd_ctl_elem_add_integer64(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id, unsigned int count, long long imin, long long imax, long long istep);
  375. int snd_ctl_elem_add_boolean(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id, unsigned int count);
  376. int snd_ctl_elem_add_iec958(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id);
  377. int snd_ctl_elem_remove(snd_ctl_t *ctl, snd_ctl_elem_id_t *id);
  378.  
  379. size_t snd_ctl_elem_value_sizeof(void);
  380. /** \hideinitializer
  381.  * \brief allocate an invalid #snd_ctl_elem_value_t using standard alloca
  382.  * \param ptr returned pointer
  383.  */
  384. #define snd_ctl_elem_value_alloca(ptr) do { assert(ptr); *ptr = (snd_ctl_elem_value_t *) alloca(snd_ctl_elem_value_sizeof()); memset(*ptr, 0, snd_ctl_elem_value_sizeof()); } while (0)
  385. int snd_ctl_elem_value_malloc(snd_ctl_elem_value_t **ptr);
  386. void snd_ctl_elem_value_free(snd_ctl_elem_value_t *obj);
  387. void snd_ctl_elem_value_clear(snd_ctl_elem_value_t *obj);
  388. void snd_ctl_elem_value_copy(snd_ctl_elem_value_t *dst, const snd_ctl_elem_value_t *src);
  389. void snd_ctl_elem_value_get_id(const snd_ctl_elem_value_t *obj, snd_ctl_elem_id_t *ptr);
  390. unsigned int snd_ctl_elem_value_get_numid(const snd_ctl_elem_value_t *obj);
  391. snd_ctl_elem_iface_t snd_ctl_elem_value_get_interface(const snd_ctl_elem_value_t *obj);
  392. unsigned int snd_ctl_elem_value_get_device(const snd_ctl_elem_value_t *obj);
  393. unsigned int snd_ctl_elem_value_get_subdevice(const snd_ctl_elem_value_t *obj);
  394. const char *snd_ctl_elem_value_get_name(const snd_ctl_elem_value_t *obj);
  395. unsigned int snd_ctl_elem_value_get_index(const snd_ctl_elem_value_t *obj);
  396. void snd_ctl_elem_value_set_id(snd_ctl_elem_value_t *obj, const snd_ctl_elem_id_t *ptr);
  397. void snd_ctl_elem_value_set_numid(snd_ctl_elem_value_t *obj, unsigned int val);
  398. void snd_ctl_elem_value_set_interface(snd_ctl_elem_value_t *obj, snd_ctl_elem_iface_t val);
  399. void snd_ctl_elem_value_set_device(snd_ctl_elem_value_t *obj, unsigned int val);
  400. void snd_ctl_elem_value_set_subdevice(snd_ctl_elem_value_t *obj, unsigned int val);
  401. void snd_ctl_elem_value_set_name(snd_ctl_elem_value_t *obj, const char *val);
  402. void snd_ctl_elem_value_set_index(snd_ctl_elem_value_t *obj, unsigned int val);
  403. int snd_ctl_elem_value_get_boolean(const snd_ctl_elem_value_t *obj, unsigned int idx);
  404. long snd_ctl_elem_value_get_integer(const snd_ctl_elem_value_t *obj, unsigned int idx);
  405. long long snd_ctl_elem_value_get_integer64(const snd_ctl_elem_value_t *obj, unsigned int idx);
  406. unsigned int snd_ctl_elem_value_get_enumerated(const snd_ctl_elem_value_t *obj, unsigned int idx);
  407. unsigned char snd_ctl_elem_value_get_byte(const snd_ctl_elem_value_t *obj, unsigned int idx);
  408. void snd_ctl_elem_value_set_boolean(snd_ctl_elem_value_t *obj, unsigned int idx, long val);
  409. void snd_ctl_elem_value_set_integer(snd_ctl_elem_value_t *obj, unsigned int idx, long val);
  410. void snd_ctl_elem_value_set_integer64(snd_ctl_elem_value_t *obj, unsigned int idx, long long val);
  411. void snd_ctl_elem_value_set_enumerated(snd_ctl_elem_value_t *obj, unsigned int idx, unsigned int val);
  412. void snd_ctl_elem_value_set_byte(snd_ctl_elem_value_t *obj, unsigned int idx, unsigned char val);
  413. void snd_ctl_elem_set_bytes(snd_ctl_elem_value_t *obj, void *data, size_t size);
  414. const void * snd_ctl_elem_value_get_bytes(const snd_ctl_elem_value_t *obj);
  415. void snd_ctl_elem_value_get_iec958(const snd_ctl_elem_value_t *obj, snd_aes_iec958_t *ptr);
  416. void snd_ctl_elem_value_set_iec958(snd_ctl_elem_value_t *obj, const snd_aes_iec958_t *ptr);
  417.  
  418. /**
  419.  *  \defgroup HControl High level Control Interface
  420.  *  \ingroup Control
  421.  *  The high level control interface.
  422.  *  See \ref hcontrol page for more details.
  423.  *  \{
  424.  */
  425.  
  426. /** HCTL element handle */
  427. typedef struct _snd_hctl_elem snd_hctl_elem_t;
  428.  
  429. /** HCTL handle */
  430. typedef struct _snd_hctl snd_hctl_t;
  431.  
  432. /**
  433.  * \brief Compare function for sorting HCTL elements
  434.  * \param e1 First element
  435.  * \param e2 Second element
  436.  * \return -1 if e1 < e2, 0 if e1 == e2, 1 if e1 > e2
  437.  */
  438. typedef int (*snd_hctl_compare_t)(const snd_hctl_elem_t *e1,
  439.                   const snd_hctl_elem_t *e2);
  440. int snd_hctl_compare_fast(const snd_hctl_elem_t *c1,
  441.               const snd_hctl_elem_t *c2);
  442. /** 
  443.  * \brief HCTL callback function
  444.  * \param hctl HCTL handle
  445.  * \param mask event mask
  446.  * \param elem related HCTL element (if any)
  447.  * \return 0 on success otherwise a negative error code
  448.  */
  449. typedef int (*snd_hctl_callback_t)(snd_hctl_t *hctl,
  450.                    unsigned int mask,
  451.                    snd_hctl_elem_t *elem);
  452. /** 
  453.  * \brief HCTL element callback function
  454.  * \param elem HCTL element
  455.  * \param mask event mask
  456.  * \return 0 on success otherwise a negative error code
  457.  */
  458. typedef int (*snd_hctl_elem_callback_t)(snd_hctl_elem_t *elem,
  459.                     unsigned int mask);
  460.  
  461. int snd_hctl_open(snd_hctl_t **hctl, const char *name, int mode);
  462. int snd_hctl_open_ctl(snd_hctl_t **hctlp, snd_ctl_t *ctl);
  463. int snd_hctl_close(snd_hctl_t *hctl);
  464. int snd_hctl_nonblock(snd_hctl_t *hctl, int nonblock);
  465. int snd_hctl_poll_descriptors_count(snd_hctl_t *hctl);
  466. int snd_hctl_poll_descriptors(snd_hctl_t *hctl, struct pollfd *pfds, unsigned int space);
  467. int snd_hctl_poll_descriptors_revents(snd_hctl_t *ctl, struct pollfd *pfds, unsigned int nfds, unsigned short *revents);
  468. unsigned int snd_hctl_get_count(snd_hctl_t *hctl);
  469. int snd_hctl_set_compare(snd_hctl_t *hctl, snd_hctl_compare_t hsort);
  470. snd_hctl_elem_t *snd_hctl_first_elem(snd_hctl_t *hctl);
  471. snd_hctl_elem_t *snd_hctl_last_elem(snd_hctl_t *hctl);
  472. snd_hctl_elem_t *snd_hctl_find_elem(snd_hctl_t *hctl, const snd_ctl_elem_id_t *id);
  473. void snd_hctl_set_callback(snd_hctl_t *hctl, snd_hctl_callback_t callback);
  474. void snd_hctl_set_callback_private(snd_hctl_t *hctl, void *data);
  475. void *snd_hctl_get_callback_private(snd_hctl_t *hctl);
  476. int snd_hctl_load(snd_hctl_t *hctl);
  477. int snd_hctl_free(snd_hctl_t *hctl);
  478. int snd_hctl_handle_events(snd_hctl_t *hctl);
  479. const char *snd_hctl_name(snd_hctl_t *hctl);
  480. int snd_hctl_wait(snd_hctl_t *hctl, int timeout);
  481. snd_ctl_t *snd_hctl_ctl(snd_hctl_t *hctl);
  482.  
  483. snd_hctl_elem_t *snd_hctl_elem_next(snd_hctl_elem_t *elem);
  484. snd_hctl_elem_t *snd_hctl_elem_prev(snd_hctl_elem_t *elem);
  485. int snd_hctl_elem_info(snd_hctl_elem_t *elem, snd_ctl_elem_info_t * info);
  486. int snd_hctl_elem_read(snd_hctl_elem_t *elem, snd_ctl_elem_value_t * value);
  487. int snd_hctl_elem_write(snd_hctl_elem_t *elem, snd_ctl_elem_value_t * value);
  488.  
  489. snd_hctl_t *snd_hctl_elem_get_hctl(snd_hctl_elem_t *elem);
  490.  
  491. void snd_hctl_elem_get_id(const snd_hctl_elem_t *obj, snd_ctl_elem_id_t *ptr);
  492. unsigned int snd_hctl_elem_get_numid(const snd_hctl_elem_t *obj);
  493. snd_ctl_elem_iface_t snd_hctl_elem_get_interface(const snd_hctl_elem_t *obj);
  494. unsigned int snd_hctl_elem_get_device(const snd_hctl_elem_t *obj);
  495. unsigned int snd_hctl_elem_get_subdevice(const snd_hctl_elem_t *obj);
  496. const char *snd_hctl_elem_get_name(const snd_hctl_elem_t *obj);
  497. unsigned int snd_hctl_elem_get_index(const snd_hctl_elem_t *obj);
  498. void snd_hctl_elem_set_callback(snd_hctl_elem_t *obj, snd_hctl_elem_callback_t val);
  499. void * snd_hctl_elem_get_callback_private(const snd_hctl_elem_t *obj);
  500. void snd_hctl_elem_set_callback_private(snd_hctl_elem_t *obj, void * val);
  501.  
  502. /** \} */
  503.  
  504. /** \} */
  505.  
  506. /**
  507.  *  \defgroup SControl Setup Control Interface
  508.  *  \ingroup Control
  509.  *  The setup control interface - set or modify control elements from a configuration file.
  510.  *  \{
  511.  */
  512.  
  513. int snd_sctl_build(snd_sctl_t **ctl, snd_ctl_t *handle, snd_config_t *config,
  514.            snd_config_t *private_data, int mode);
  515. int snd_sctl_free(snd_sctl_t *handle);
  516. int snd_sctl_install(snd_sctl_t *handle);
  517. int snd_sctl_remove(snd_sctl_t *handle);
  518.  
  519. /** \} */
  520.  
  521. #ifdef __cplusplus
  522. }
  523. #endif
  524.  
  525. #endif /* __ALSA_CONTROL_H */
  526.